// $ANTLR 3.3 Nov 30, 2010 12:50:56 SQL.g 2011-04-13 23:11:05

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 219
// Unreachable code detected.
#pragma warning disable 162


using System.Collections.Generic;
using Antlr.Runtime;
using Stack = System.Collections.Generic.Stack<object>;
using List = System.Collections.IList;
using ArrayList = System.Collections.Generic.List<object>;
using Map = System.Collections.IDictionary;
using HashMap = System.Collections.Generic.Dictionary<object, object>;
namespace  Magic.Framework.OQL
{
[System.CodeDom.Compiler.GeneratedCode("ANTLR", "3.3 Nov 30, 2010 12:50:56")]
[System.CLSCompliant(false)]
public partial class SQLLexer : Antlr.Runtime.Lexer
{
	public const int EOF=-1;
	public const int Eq=4;
	public const int Neq1=5;
	public const int Neq2=6;
	public const int Le1=7;
	public const int Le2=8;
	public const int Lt=9;
	public const int Ge1=10;
	public const int Ge2=11;
	public const int Gt=12;
	public const int DIV=13;
	public const int PLUS=14;
	public const int MINUS=15;
	public const int MUL=16;
	public const int MOD=17;
	public const int BITAND=18;
	public const int BITNOT=19;
	public const int BITOR=20;
	public const int BITXOR=21;
	public const int LPAREN=22;
	public const int RPAREN=23;
	public const int COLON=24;
	public const int COMMA=25;
	public const int SEMI=26;
	public const int DOT=27;
	public const int SELECT=28;
	public const int FROM=29;
	public const int WHERE=30;
	public const int AND=31;
	public const int OR=32;
	public const int NOT=33;
	public const int NonQuotedIdentifier=34;
	public const int Integer=35;
	public const int Txt=36;
	public const int Whitespace=37;
	public const int DigitChar=38;
	public const int NonQuotedIdentifier_0=39;
	public const int LetterChar=40;
	public const int TextNode=41;
	public const int SelectClause=42;
	public const int SelectStmt=43;
	public const int WhereClause=44;
	public const int Table=45;
	public const int Column=46;
	public const int Predicate=47;
	public const int Group=48;

    // delegates
    // delegators

	public SQLLexer()
	{
		OnCreated();
	}

	public SQLLexer(ICharStream input )
		: this(input, new RecognizerSharedState())
	{
	}

	public SQLLexer(ICharStream input, RecognizerSharedState state)
		: base(input, state)
	{


		OnCreated();
	}
	public override string GrammarFileName { get { return "SQL.g"; } }

	private static readonly bool[] decisionCanBacktrack = new bool[0];


	partial void OnCreated();
	partial void EnterRule(string ruleName, int ruleIndex);
	partial void LeaveRule(string ruleName, int ruleIndex);

	partial void Enter_Eq();
	partial void Leave_Eq();

	// $ANTLR start "Eq"
	[GrammarRule("Eq")]
	private void mEq()
	{
		Enter_Eq();
		EnterRule("Eq", 1);
		TraceIn("Eq", 1);
		try
		{
			int _type = Eq;
			int _channel = DefaultTokenChannel;
			// SQL.g:9:4: ( '=' )
			DebugEnterAlt(1);
			// SQL.g:9:6: '='
			{
			DebugLocation(9, 6);
			Match('='); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("Eq", 1);
			LeaveRule("Eq", 1);
			Leave_Eq();
		}
	}
	// $ANTLR end "Eq"

	partial void Enter_Neq1();
	partial void Leave_Neq1();

	// $ANTLR start "Neq1"
	[GrammarRule("Neq1")]
	private void mNeq1()
	{
		Enter_Neq1();
		EnterRule("Neq1", 2);
		TraceIn("Neq1", 2);
		try
		{
			int _type = Neq1;
			int _channel = DefaultTokenChannel;
			// SQL.g:10:6: ( '<>' )
			DebugEnterAlt(1);
			// SQL.g:10:8: '<>'
			{
			DebugLocation(10, 8);
			Match("<>"); if (state.failed) return;


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("Neq1", 2);
			LeaveRule("Neq1", 2);
			Leave_Neq1();
		}
	}
	// $ANTLR end "Neq1"

	partial void Enter_Neq2();
	partial void Leave_Neq2();

	// $ANTLR start "Neq2"
	[GrammarRule("Neq2")]
	private void mNeq2()
	{
		Enter_Neq2();
		EnterRule("Neq2", 3);
		TraceIn("Neq2", 3);
		try
		{
			int _type = Neq2;
			int _channel = DefaultTokenChannel;
			// SQL.g:11:6: ( '!=' )
			DebugEnterAlt(1);
			// SQL.g:11:8: '!='
			{
			DebugLocation(11, 8);
			Match("!="); if (state.failed) return;


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("Neq2", 3);
			LeaveRule("Neq2", 3);
			Leave_Neq2();
		}
	}
	// $ANTLR end "Neq2"

	partial void Enter_Le1();
	partial void Leave_Le1();

	// $ANTLR start "Le1"
	[GrammarRule("Le1")]
	private void mLe1()
	{
		Enter_Le1();
		EnterRule("Le1", 4);
		TraceIn("Le1", 4);
		try
		{
			int _type = Le1;
			int _channel = DefaultTokenChannel;
			// SQL.g:12:5: ( '<=' )
			DebugEnterAlt(1);
			// SQL.g:12:7: '<='
			{
			DebugLocation(12, 7);
			Match("<="); if (state.failed) return;


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("Le1", 4);
			LeaveRule("Le1", 4);
			Leave_Le1();
		}
	}
	// $ANTLR end "Le1"

	partial void Enter_Le2();
	partial void Leave_Le2();

	// $ANTLR start "Le2"
	[GrammarRule("Le2")]
	private void mLe2()
	{
		Enter_Le2();
		EnterRule("Le2", 5);
		TraceIn("Le2", 5);
		try
		{
			int _type = Le2;
			int _channel = DefaultTokenChannel;
			// SQL.g:13:5: ( '!>' )
			DebugEnterAlt(1);
			// SQL.g:13:7: '!>'
			{
			DebugLocation(13, 7);
			Match("!>"); if (state.failed) return;


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("Le2", 5);
			LeaveRule("Le2", 5);
			Leave_Le2();
		}
	}
	// $ANTLR end "Le2"

	partial void Enter_Lt();
	partial void Leave_Lt();

	// $ANTLR start "Lt"
	[GrammarRule("Lt")]
	private void mLt()
	{
		Enter_Lt();
		EnterRule("Lt", 6);
		TraceIn("Lt", 6);
		try
		{
			int _type = Lt;
			int _channel = DefaultTokenChannel;
			// SQL.g:14:4: ( '<' )
			DebugEnterAlt(1);
			// SQL.g:14:6: '<'
			{
			DebugLocation(14, 6);
			Match('<'); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("Lt", 6);
			LeaveRule("Lt", 6);
			Leave_Lt();
		}
	}
	// $ANTLR end "Lt"

	partial void Enter_Ge1();
	partial void Leave_Ge1();

	// $ANTLR start "Ge1"
	[GrammarRule("Ge1")]
	private void mGe1()
	{
		Enter_Ge1();
		EnterRule("Ge1", 7);
		TraceIn("Ge1", 7);
		try
		{
			int _type = Ge1;
			int _channel = DefaultTokenChannel;
			// SQL.g:15:5: ( '>=' )
			DebugEnterAlt(1);
			// SQL.g:15:7: '>='
			{
			DebugLocation(15, 7);
			Match(">="); if (state.failed) return;


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("Ge1", 7);
			LeaveRule("Ge1", 7);
			Leave_Ge1();
		}
	}
	// $ANTLR end "Ge1"

	partial void Enter_Ge2();
	partial void Leave_Ge2();

	// $ANTLR start "Ge2"
	[GrammarRule("Ge2")]
	private void mGe2()
	{
		Enter_Ge2();
		EnterRule("Ge2", 8);
		TraceIn("Ge2", 8);
		try
		{
			int _type = Ge2;
			int _channel = DefaultTokenChannel;
			// SQL.g:16:5: ( '!<' )
			DebugEnterAlt(1);
			// SQL.g:16:7: '!<'
			{
			DebugLocation(16, 7);
			Match("!<"); if (state.failed) return;


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("Ge2", 8);
			LeaveRule("Ge2", 8);
			Leave_Ge2();
		}
	}
	// $ANTLR end "Ge2"

	partial void Enter_Gt();
	partial void Leave_Gt();

	// $ANTLR start "Gt"
	[GrammarRule("Gt")]
	private void mGt()
	{
		Enter_Gt();
		EnterRule("Gt", 9);
		TraceIn("Gt", 9);
		try
		{
			int _type = Gt;
			int _channel = DefaultTokenChannel;
			// SQL.g:17:4: ( '>' )
			DebugEnterAlt(1);
			// SQL.g:17:6: '>'
			{
			DebugLocation(17, 6);
			Match('>'); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("Gt", 9);
			LeaveRule("Gt", 9);
			Leave_Gt();
		}
	}
	// $ANTLR end "Gt"

	partial void Enter_DIV();
	partial void Leave_DIV();

	// $ANTLR start "DIV"
	[GrammarRule("DIV")]
	private void mDIV()
	{
		Enter_DIV();
		EnterRule("DIV", 10);
		TraceIn("DIV", 10);
		try
		{
			int _type = DIV;
			int _channel = DefaultTokenChannel;
			// SQL.g:18:5: ( '/' )
			DebugEnterAlt(1);
			// SQL.g:18:7: '/'
			{
			DebugLocation(18, 7);
			Match('/'); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("DIV", 10);
			LeaveRule("DIV", 10);
			Leave_DIV();
		}
	}
	// $ANTLR end "DIV"

	partial void Enter_PLUS();
	partial void Leave_PLUS();

	// $ANTLR start "PLUS"
	[GrammarRule("PLUS")]
	private void mPLUS()
	{
		Enter_PLUS();
		EnterRule("PLUS", 11);
		TraceIn("PLUS", 11);
		try
		{
			int _type = PLUS;
			int _channel = DefaultTokenChannel;
			// SQL.g:19:6: ( '+' )
			DebugEnterAlt(1);
			// SQL.g:19:8: '+'
			{
			DebugLocation(19, 8);
			Match('+'); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("PLUS", 11);
			LeaveRule("PLUS", 11);
			Leave_PLUS();
		}
	}
	// $ANTLR end "PLUS"

	partial void Enter_MINUS();
	partial void Leave_MINUS();

	// $ANTLR start "MINUS"
	[GrammarRule("MINUS")]
	private void mMINUS()
	{
		Enter_MINUS();
		EnterRule("MINUS", 12);
		TraceIn("MINUS", 12);
		try
		{
			int _type = MINUS;
			int _channel = DefaultTokenChannel;
			// SQL.g:20:7: ( '-' )
			DebugEnterAlt(1);
			// SQL.g:20:9: '-'
			{
			DebugLocation(20, 9);
			Match('-'); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("MINUS", 12);
			LeaveRule("MINUS", 12);
			Leave_MINUS();
		}
	}
	// $ANTLR end "MINUS"

	partial void Enter_MUL();
	partial void Leave_MUL();

	// $ANTLR start "MUL"
	[GrammarRule("MUL")]
	private void mMUL()
	{
		Enter_MUL();
		EnterRule("MUL", 13);
		TraceIn("MUL", 13);
		try
		{
			int _type = MUL;
			int _channel = DefaultTokenChannel;
			// SQL.g:21:5: ( '*' )
			DebugEnterAlt(1);
			// SQL.g:21:7: '*'
			{
			DebugLocation(21, 7);
			Match('*'); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("MUL", 13);
			LeaveRule("MUL", 13);
			Leave_MUL();
		}
	}
	// $ANTLR end "MUL"

	partial void Enter_MOD();
	partial void Leave_MOD();

	// $ANTLR start "MOD"
	[GrammarRule("MOD")]
	private void mMOD()
	{
		Enter_MOD();
		EnterRule("MOD", 14);
		TraceIn("MOD", 14);
		try
		{
			int _type = MOD;
			int _channel = DefaultTokenChannel;
			// SQL.g:22:5: ( '%' )
			DebugEnterAlt(1);
			// SQL.g:22:7: '%'
			{
			DebugLocation(22, 7);
			Match('%'); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("MOD", 14);
			LeaveRule("MOD", 14);
			Leave_MOD();
		}
	}
	// $ANTLR end "MOD"

	partial void Enter_BITAND();
	partial void Leave_BITAND();

	// $ANTLR start "BITAND"
	[GrammarRule("BITAND")]
	private void mBITAND()
	{
		Enter_BITAND();
		EnterRule("BITAND", 15);
		TraceIn("BITAND", 15);
		try
		{
			int _type = BITAND;
			int _channel = DefaultTokenChannel;
			// SQL.g:23:8: ( '&' )
			DebugEnterAlt(1);
			// SQL.g:23:10: '&'
			{
			DebugLocation(23, 10);
			Match('&'); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("BITAND", 15);
			LeaveRule("BITAND", 15);
			Leave_BITAND();
		}
	}
	// $ANTLR end "BITAND"

	partial void Enter_BITNOT();
	partial void Leave_BITNOT();

	// $ANTLR start "BITNOT"
	[GrammarRule("BITNOT")]
	private void mBITNOT()
	{
		Enter_BITNOT();
		EnterRule("BITNOT", 16);
		TraceIn("BITNOT", 16);
		try
		{
			int _type = BITNOT;
			int _channel = DefaultTokenChannel;
			// SQL.g:24:8: ( '~' )
			DebugEnterAlt(1);
			// SQL.g:24:10: '~'
			{
			DebugLocation(24, 10);
			Match('~'); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("BITNOT", 16);
			LeaveRule("BITNOT", 16);
			Leave_BITNOT();
		}
	}
	// $ANTLR end "BITNOT"

	partial void Enter_BITOR();
	partial void Leave_BITOR();

	// $ANTLR start "BITOR"
	[GrammarRule("BITOR")]
	private void mBITOR()
	{
		Enter_BITOR();
		EnterRule("BITOR", 17);
		TraceIn("BITOR", 17);
		try
		{
			int _type = BITOR;
			int _channel = DefaultTokenChannel;
			// SQL.g:25:7: ( '|' )
			DebugEnterAlt(1);
			// SQL.g:25:9: '|'
			{
			DebugLocation(25, 9);
			Match('|'); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("BITOR", 17);
			LeaveRule("BITOR", 17);
			Leave_BITOR();
		}
	}
	// $ANTLR end "BITOR"

	partial void Enter_BITXOR();
	partial void Leave_BITXOR();

	// $ANTLR start "BITXOR"
	[GrammarRule("BITXOR")]
	private void mBITXOR()
	{
		Enter_BITXOR();
		EnterRule("BITXOR", 18);
		TraceIn("BITXOR", 18);
		try
		{
			int _type = BITXOR;
			int _channel = DefaultTokenChannel;
			// SQL.g:26:8: ( '^' )
			DebugEnterAlt(1);
			// SQL.g:26:10: '^'
			{
			DebugLocation(26, 10);
			Match('^'); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("BITXOR", 18);
			LeaveRule("BITXOR", 18);
			Leave_BITXOR();
		}
	}
	// $ANTLR end "BITXOR"

	partial void Enter_LPAREN();
	partial void Leave_LPAREN();

	// $ANTLR start "LPAREN"
	[GrammarRule("LPAREN")]
	private void mLPAREN()
	{
		Enter_LPAREN();
		EnterRule("LPAREN", 19);
		TraceIn("LPAREN", 19);
		try
		{
			int _type = LPAREN;
			int _channel = DefaultTokenChannel;
			// SQL.g:27:8: ( '(' )
			DebugEnterAlt(1);
			// SQL.g:27:10: '('
			{
			DebugLocation(27, 10);
			Match('('); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("LPAREN", 19);
			LeaveRule("LPAREN", 19);
			Leave_LPAREN();
		}
	}
	// $ANTLR end "LPAREN"

	partial void Enter_RPAREN();
	partial void Leave_RPAREN();

	// $ANTLR start "RPAREN"
	[GrammarRule("RPAREN")]
	private void mRPAREN()
	{
		Enter_RPAREN();
		EnterRule("RPAREN", 20);
		TraceIn("RPAREN", 20);
		try
		{
			int _type = RPAREN;
			int _channel = DefaultTokenChannel;
			// SQL.g:28:8: ( ')' )
			DebugEnterAlt(1);
			// SQL.g:28:10: ')'
			{
			DebugLocation(28, 10);
			Match(')'); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("RPAREN", 20);
			LeaveRule("RPAREN", 20);
			Leave_RPAREN();
		}
	}
	// $ANTLR end "RPAREN"

	partial void Enter_COLON();
	partial void Leave_COLON();

	// $ANTLR start "COLON"
	[GrammarRule("COLON")]
	private void mCOLON()
	{
		Enter_COLON();
		EnterRule("COLON", 21);
		TraceIn("COLON", 21);
		try
		{
			int _type = COLON;
			int _channel = DefaultTokenChannel;
			// SQL.g:29:7: ( ':' )
			DebugEnterAlt(1);
			// SQL.g:29:9: ':'
			{
			DebugLocation(29, 9);
			Match(':'); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("COLON", 21);
			LeaveRule("COLON", 21);
			Leave_COLON();
		}
	}
	// $ANTLR end "COLON"

	partial void Enter_COMMA();
	partial void Leave_COMMA();

	// $ANTLR start "COMMA"
	[GrammarRule("COMMA")]
	private void mCOMMA()
	{
		Enter_COMMA();
		EnterRule("COMMA", 22);
		TraceIn("COMMA", 22);
		try
		{
			int _type = COMMA;
			int _channel = DefaultTokenChannel;
			// SQL.g:30:7: ( ',' )
			DebugEnterAlt(1);
			// SQL.g:30:9: ','
			{
			DebugLocation(30, 9);
			Match(','); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("COMMA", 22);
			LeaveRule("COMMA", 22);
			Leave_COMMA();
		}
	}
	// $ANTLR end "COMMA"

	partial void Enter_SEMI();
	partial void Leave_SEMI();

	// $ANTLR start "SEMI"
	[GrammarRule("SEMI")]
	private void mSEMI()
	{
		Enter_SEMI();
		EnterRule("SEMI", 23);
		TraceIn("SEMI", 23);
		try
		{
			int _type = SEMI;
			int _channel = DefaultTokenChannel;
			// SQL.g:31:6: ( ';' )
			DebugEnterAlt(1);
			// SQL.g:31:8: ';'
			{
			DebugLocation(31, 8);
			Match(';'); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("SEMI", 23);
			LeaveRule("SEMI", 23);
			Leave_SEMI();
		}
	}
	// $ANTLR end "SEMI"

	partial void Enter_DOT();
	partial void Leave_DOT();

	// $ANTLR start "DOT"
	[GrammarRule("DOT")]
	private void mDOT()
	{
		Enter_DOT();
		EnterRule("DOT", 24);
		TraceIn("DOT", 24);
		try
		{
			int _type = DOT;
			int _channel = DefaultTokenChannel;
			// SQL.g:32:5: ( '.' )
			DebugEnterAlt(1);
			// SQL.g:32:7: '.'
			{
			DebugLocation(32, 7);
			Match('.'); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("DOT", 24);
			LeaveRule("DOT", 24);
			Leave_DOT();
		}
	}
	// $ANTLR end "DOT"

	partial void Enter_AND();
	partial void Leave_AND();

	// $ANTLR start "AND"
	[GrammarRule("AND")]
	private void mAND()
	{
		Enter_AND();
		EnterRule("AND", 25);
		TraceIn("AND", 25);
		try
		{
			int _type = AND;
			int _channel = DefaultTokenChannel;
			// SQL.g:247:5: ( ( 'A' | 'a' ) ( 'N' | 'n' ) ( 'D' | 'd' ) )
			DebugEnterAlt(1);
			// SQL.g:247:7: ( 'A' | 'a' ) ( 'N' | 'n' ) ( 'D' | 'd' )
			{
			DebugLocation(247, 7);
			if (input.LA(1)=='A'||input.LA(1)=='a')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(247, 16);
			if (input.LA(1)=='N'||input.LA(1)=='n')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(247, 25);
			if (input.LA(1)=='D'||input.LA(1)=='d')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("AND", 25);
			LeaveRule("AND", 25);
			Leave_AND();
		}
	}
	// $ANTLR end "AND"

	partial void Enter_OR();
	partial void Leave_OR();

	// $ANTLR start "OR"
	[GrammarRule("OR")]
	private void mOR()
	{
		Enter_OR();
		EnterRule("OR", 26);
		TraceIn("OR", 26);
		try
		{
			int _type = OR;
			int _channel = DefaultTokenChannel;
			// SQL.g:248:4: ( ( 'O' | 'o' ) ( 'r' | 'R' ) )
			DebugEnterAlt(1);
			// SQL.g:248:6: ( 'O' | 'o' ) ( 'r' | 'R' )
			{
			DebugLocation(248, 6);
			if (input.LA(1)=='O'||input.LA(1)=='o')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(248, 15);
			if (input.LA(1)=='R'||input.LA(1)=='r')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("OR", 26);
			LeaveRule("OR", 26);
			Leave_OR();
		}
	}
	// $ANTLR end "OR"

	partial void Enter_NOT();
	partial void Leave_NOT();

	// $ANTLR start "NOT"
	[GrammarRule("NOT")]
	private void mNOT()
	{
		Enter_NOT();
		EnterRule("NOT", 27);
		TraceIn("NOT", 27);
		try
		{
			int _type = NOT;
			int _channel = DefaultTokenChannel;
			// SQL.g:249:5: ( ( 'N' | 'n' ) ( 'o' | 'O' ) ( 'T' | 't' ) )
			DebugEnterAlt(1);
			// SQL.g:249:7: ( 'N' | 'n' ) ( 'o' | 'O' ) ( 'T' | 't' )
			{
			DebugLocation(249, 7);
			if (input.LA(1)=='N'||input.LA(1)=='n')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(249, 16);
			if (input.LA(1)=='O'||input.LA(1)=='o')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(249, 25);
			if (input.LA(1)=='T'||input.LA(1)=='t')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("NOT", 27);
			LeaveRule("NOT", 27);
			Leave_NOT();
		}
	}
	// $ANTLR end "NOT"

	partial void Enter_SELECT();
	partial void Leave_SELECT();

	// $ANTLR start "SELECT"
	[GrammarRule("SELECT")]
	private void mSELECT()
	{
		Enter_SELECT();
		EnterRule("SELECT", 28);
		TraceIn("SELECT", 28);
		try
		{
			int _type = SELECT;
			int _channel = DefaultTokenChannel;
			// SQL.g:250:8: ( ( 's' | 'S' ) ( 'e' | 'E' ) ( 'l' | 'L' ) ( 'e' | 'E' ) ( 'c' | 'C' ) ( 't' | 'T' ) )
			DebugEnterAlt(1);
			// SQL.g:250:10: ( 's' | 'S' ) ( 'e' | 'E' ) ( 'l' | 'L' ) ( 'e' | 'E' ) ( 'c' | 'C' ) ( 't' | 'T' )
			{
			DebugLocation(250, 10);
			if (input.LA(1)=='S'||input.LA(1)=='s')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(250, 19);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(250, 28);
			if (input.LA(1)=='L'||input.LA(1)=='l')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(250, 37);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(250, 46);
			if (input.LA(1)=='C'||input.LA(1)=='c')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(250, 55);
			if (input.LA(1)=='T'||input.LA(1)=='t')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("SELECT", 28);
			LeaveRule("SELECT", 28);
			Leave_SELECT();
		}
	}
	// $ANTLR end "SELECT"

	partial void Enter_WHERE();
	partial void Leave_WHERE();

	// $ANTLR start "WHERE"
	[GrammarRule("WHERE")]
	private void mWHERE()
	{
		Enter_WHERE();
		EnterRule("WHERE", 29);
		TraceIn("WHERE", 29);
		try
		{
			int _type = WHERE;
			int _channel = DefaultTokenChannel;
			// SQL.g:251:7: ( ( 'w' | 'W' ) ( 'h' | 'H' ) ( 'e' | 'E' ) ( 'r' | 'R' ) ( 'e' | 'E' ) )
			DebugEnterAlt(1);
			// SQL.g:251:9: ( 'w' | 'W' ) ( 'h' | 'H' ) ( 'e' | 'E' ) ( 'r' | 'R' ) ( 'e' | 'E' )
			{
			DebugLocation(251, 9);
			if (input.LA(1)=='W'||input.LA(1)=='w')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(251, 18);
			if (input.LA(1)=='H'||input.LA(1)=='h')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(251, 27);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(251, 36);
			if (input.LA(1)=='R'||input.LA(1)=='r')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(251, 45);
			if (input.LA(1)=='E'||input.LA(1)=='e')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("WHERE", 29);
			LeaveRule("WHERE", 29);
			Leave_WHERE();
		}
	}
	// $ANTLR end "WHERE"

	partial void Enter_FROM();
	partial void Leave_FROM();

	// $ANTLR start "FROM"
	[GrammarRule("FROM")]
	private void mFROM()
	{
		Enter_FROM();
		EnterRule("FROM", 30);
		TraceIn("FROM", 30);
		try
		{
			int _type = FROM;
			int _channel = DefaultTokenChannel;
			// SQL.g:252:6: ( ( 'f' | 'F' ) ( 'r' | 'R' ) ( 'o' | 'O' ) ( 'm' | 'M' ) )
			DebugEnterAlt(1);
			// SQL.g:252:8: ( 'f' | 'F' ) ( 'r' | 'R' ) ( 'o' | 'O' ) ( 'm' | 'M' )
			{
			DebugLocation(252, 8);
			if (input.LA(1)=='F'||input.LA(1)=='f')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(252, 17);
			if (input.LA(1)=='R'||input.LA(1)=='r')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(252, 26);
			if (input.LA(1)=='O'||input.LA(1)=='o')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(252, 35);
			if (input.LA(1)=='M'||input.LA(1)=='m')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("FROM", 30);
			LeaveRule("FROM", 30);
			Leave_FROM();
		}
	}
	// $ANTLR end "FROM"

	partial void Enter_Whitespace();
	partial void Leave_Whitespace();

	// $ANTLR start "Whitespace"
	[GrammarRule("Whitespace")]
	private void mWhitespace()
	{
		Enter_Whitespace();
		EnterRule("Whitespace", 31);
		TraceIn("Whitespace", 31);
		try
		{
			int _type = Whitespace;
			int _channel = DefaultTokenChannel;
			// SQL.g:255:5: ( ( ' ' | '\\t' | '\\n' | '\\r' ) )
			DebugEnterAlt(1);
			// SQL.g:255:7: ( ' ' | '\\t' | '\\n' | '\\r' )
			{
			DebugLocation(255, 7);
			if ((input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ')
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(255, 33);
			if ( state.backtracking == 0 )
			{
				 _channel = Hidden; 
			}

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("Whitespace", 31);
			LeaveRule("Whitespace", 31);
			Leave_Whitespace();
		}
	}
	// $ANTLR end "Whitespace"

	partial void Enter_Integer();
	partial void Leave_Integer();

	// $ANTLR start "Integer"
	[GrammarRule("Integer")]
	private void mInteger()
	{
		Enter_Integer();
		EnterRule("Integer", 32);
		TraceIn("Integer", 32);
		try
		{
			int _type = Integer;
			int _channel = DefaultTokenChannel;
			// SQL.g:260:9: ( ( DigitChar )+ )
			DebugEnterAlt(1);
			// SQL.g:260:10: ( DigitChar )+
			{
			DebugLocation(260, 10);
			// SQL.g:260:10: ( DigitChar )+
			int cnt1=0;
			try { DebugEnterSubRule(1);
			while (true)
			{
				int alt1=2;
				try { DebugEnterDecision(1, decisionCanBacktrack[1]);
				int LA1_0 = input.LA(1);

				if (((LA1_0>='0' && LA1_0<='9')))
				{
					alt1=1;
				}


				} finally { DebugExitDecision(1); }
				switch (alt1)
				{
				case 1:
					DebugEnterAlt(1);
					// SQL.g:260:11: DigitChar
					{
					DebugLocation(260, 11);
					mDigitChar(); if (state.failed) return;

					}
					break;

				default:
					if (cnt1 >= 1)
						goto loop1;

					if (state.backtracking>0) {state.failed=true; return;}
					EarlyExitException eee1 = new EarlyExitException( 1, input );
					DebugRecognitionException(eee1);
					throw eee1;
				}
				cnt1++;
			}
			loop1:
				;

			} finally { DebugExitSubRule(1); }


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("Integer", 32);
			LeaveRule("Integer", 32);
			Leave_Integer();
		}
	}
	// $ANTLR end "Integer"

	partial void Enter_Txt();
	partial void Leave_Txt();

	// $ANTLR start "Txt"
	[GrammarRule("Txt")]
	private void mTxt()
	{
		Enter_Txt();
		EnterRule("Txt", 33);
		TraceIn("Txt", 33);
		try
		{
			int _type = Txt;
			int _channel = DefaultTokenChannel;
			// SQL.g:269:2: ( '\"' (~ '\"' )* '\"' | '\\'' (~ ( '\\\\' | '\\'' ) )* '\\'' )
			int alt4=2;
			try { DebugEnterDecision(4, decisionCanBacktrack[4]);
			int LA4_0 = input.LA(1);

			if ((LA4_0=='\"'))
			{
				alt4=1;
			}
			else if ((LA4_0=='\''))
			{
				alt4=2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				NoViableAltException nvae = new NoViableAltException("", 4, 0, input);

				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(4); }
			switch (alt4)
			{
			case 1:
				DebugEnterAlt(1);
				// SQL.g:269:3: '\"' (~ '\"' )* '\"'
				{
				DebugLocation(269, 3);
				Match('\"'); if (state.failed) return;
				DebugLocation(269, 7);
				// SQL.g:269:7: (~ '\"' )*
				try { DebugEnterSubRule(2);
				while (true)
				{
					int alt2=2;
					try { DebugEnterDecision(2, decisionCanBacktrack[2]);
					int LA2_0 = input.LA(1);

					if (((LA2_0>='\u0000' && LA2_0<='!')||(LA2_0>='#' && LA2_0<='\uFFFF')))
					{
						alt2=1;
					}


					} finally { DebugExitDecision(2); }
					switch ( alt2 )
					{
					case 1:
						DebugEnterAlt(1);
						// SQL.g:269:8: ~ '\"'
						{
						DebugLocation(269, 8);
						if ((input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='\uFFFF'))
						{
							input.Consume();
						state.failed=false;
						}
						else
						{
							if (state.backtracking>0) {state.failed=true; return;}
							MismatchedSetException mse = new MismatchedSetException(null,input);
							DebugRecognitionException(mse);
							Recover(mse);
							throw mse;}


						}
						break;

					default:
						goto loop2;
					}
				}

				loop2:
					;

				} finally { DebugExitSubRule(2); }

				DebugLocation(269, 15);
				Match('\"'); if (state.failed) return;

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// SQL.g:270:3: '\\'' (~ ( '\\\\' | '\\'' ) )* '\\''
				{
				DebugLocation(270, 3);
				Match('\''); if (state.failed) return;
				DebugLocation(270, 8);
				// SQL.g:270:8: (~ ( '\\\\' | '\\'' ) )*
				try { DebugEnterSubRule(3);
				while (true)
				{
					int alt3=2;
					try { DebugEnterDecision(3, decisionCanBacktrack[3]);
					int LA3_0 = input.LA(1);

					if (((LA3_0>='\u0000' && LA3_0<='&')||(LA3_0>='(' && LA3_0<='[')||(LA3_0>=']' && LA3_0<='\uFFFF')))
					{
						alt3=1;
					}


					} finally { DebugExitDecision(3); }
					switch ( alt3 )
					{
					case 1:
						DebugEnterAlt(1);
						// SQL.g:270:10: ~ ( '\\\\' | '\\'' )
						{
						DebugLocation(270, 10);
						if ((input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF'))
						{
							input.Consume();
						state.failed=false;
						}
						else
						{
							if (state.backtracking>0) {state.failed=true; return;}
							MismatchedSetException mse = new MismatchedSetException(null,input);
							DebugRecognitionException(mse);
							Recover(mse);
							throw mse;}


						}
						break;

					default:
						goto loop3;
					}
				}

				loop3:
					;

				} finally { DebugExitSubRule(3); }

				DebugLocation(270, 25);
				Match('\''); if (state.failed) return;

				}
				break;

			}
			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("Txt", 33);
			LeaveRule("Txt", 33);
			Leave_Txt();
		}
	}
	// $ANTLR end "Txt"

	partial void Enter_NonQuotedIdentifier();
	partial void Leave_NonQuotedIdentifier();

	// $ANTLR start "NonQuotedIdentifier"
	[GrammarRule("NonQuotedIdentifier")]
	private void mNonQuotedIdentifier()
	{
		Enter_NonQuotedIdentifier();
		EnterRule("NonQuotedIdentifier", 34);
		TraceIn("NonQuotedIdentifier", 34);
		try
		{
			int _type = NonQuotedIdentifier;
			int _channel = DefaultTokenChannel;
			// SQL.g:275:30: ( NonQuotedIdentifier_0 ( DOT NonQuotedIdentifier_0 )* ( DOT MUL )? )
			DebugEnterAlt(1);
			// SQL.g:276:7: NonQuotedIdentifier_0 ( DOT NonQuotedIdentifier_0 )* ( DOT MUL )?
			{
			DebugLocation(276, 7);
			mNonQuotedIdentifier_0(); if (state.failed) return;
			DebugLocation(276, 29);
			// SQL.g:276:29: ( DOT NonQuotedIdentifier_0 )*
			try { DebugEnterSubRule(5);
			while (true)
			{
				int alt5=2;
				try { DebugEnterDecision(5, decisionCanBacktrack[5]);
				int LA5_0 = input.LA(1);

				if ((LA5_0=='.'))
				{
					int LA5_1 = input.LA(2);

					if (((LA5_1>='A' && LA5_1<='Z')||(LA5_1>='a' && LA5_1<='z')))
					{
						alt5=1;
					}


				}


				} finally { DebugExitDecision(5); }
				switch ( alt5 )
				{
				case 1:
					DebugEnterAlt(1);
					// SQL.g:276:30: DOT NonQuotedIdentifier_0
					{
					DebugLocation(276, 30);
					mDOT(); if (state.failed) return;
					DebugLocation(276, 34);
					mNonQuotedIdentifier_0(); if (state.failed) return;

					}
					break;

				default:
					goto loop5;
				}
			}

			loop5:
				;

			} finally { DebugExitSubRule(5); }

			DebugLocation(276, 58);
			// SQL.g:276:58: ( DOT MUL )?
			int alt6=2;
			try { DebugEnterSubRule(6);
			try { DebugEnterDecision(6, decisionCanBacktrack[6]);
			int LA6_0 = input.LA(1);

			if ((LA6_0=='.'))
			{
				alt6=1;
			}
			} finally { DebugExitDecision(6); }
			switch (alt6)
			{
			case 1:
				DebugEnterAlt(1);
				// SQL.g:276:59: DOT MUL
				{
				DebugLocation(276, 59);
				mDOT(); if (state.failed) return;
				DebugLocation(276, 63);
				mMUL(); if (state.failed) return;

				}
				break;

			}
			} finally { DebugExitSubRule(6); }


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("NonQuotedIdentifier", 34);
			LeaveRule("NonQuotedIdentifier", 34);
			Leave_NonQuotedIdentifier();
		}
	}
	// $ANTLR end "NonQuotedIdentifier"

	partial void Enter_NonQuotedIdentifier_0();
	partial void Leave_NonQuotedIdentifier_0();

	// $ANTLR start "NonQuotedIdentifier_0"
	[GrammarRule("NonQuotedIdentifier_0")]
	private void mNonQuotedIdentifier_0()
	{
		Enter_NonQuotedIdentifier_0();
		EnterRule("NonQuotedIdentifier_0", 35);
		TraceIn("NonQuotedIdentifier_0", 35);
		try
		{
			// SQL.g:279:2: ( LetterChar ( LetterChar | DigitChar | '_' )* )
			DebugEnterAlt(1);
			// SQL.g:279:4: LetterChar ( LetterChar | DigitChar | '_' )*
			{
			DebugLocation(279, 4);
			mLetterChar(); if (state.failed) return;
			DebugLocation(279, 15);
			// SQL.g:279:15: ( LetterChar | DigitChar | '_' )*
			try { DebugEnterSubRule(7);
			while (true)
			{
				int alt7=2;
				try { DebugEnterDecision(7, decisionCanBacktrack[7]);
				int LA7_0 = input.LA(1);

				if (((LA7_0>='0' && LA7_0<='9')||(LA7_0>='A' && LA7_0<='Z')||LA7_0=='_'||(LA7_0>='a' && LA7_0<='z')))
				{
					alt7=1;
				}


				} finally { DebugExitDecision(7); }
				switch ( alt7 )
				{
				case 1:
					DebugEnterAlt(1);
					// SQL.g:
					{
					DebugLocation(279, 15);
					if ((input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z'))
					{
						input.Consume();
					state.failed=false;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return;}
						MismatchedSetException mse = new MismatchedSetException(null,input);
						DebugRecognitionException(mse);
						Recover(mse);
						throw mse;}


					}
					break;

				default:
					goto loop7;
				}
			}

			loop7:
				;

			} finally { DebugExitSubRule(7); }


			}

		}
		finally
		{
			TraceOut("NonQuotedIdentifier_0", 35);
			LeaveRule("NonQuotedIdentifier_0", 35);
			Leave_NonQuotedIdentifier_0();
		}
	}
	// $ANTLR end "NonQuotedIdentifier_0"

	partial void Enter_LetterChar();
	partial void Leave_LetterChar();

	// $ANTLR start "LetterChar"
	[GrammarRule("LetterChar")]
	private void mLetterChar()
	{
		Enter_LetterChar();
		EnterRule("LetterChar", 36);
		TraceIn("LetterChar", 36);
		try
		{
			// SQL.g:282:20: ( 'a' .. 'z' | 'A' .. 'Z' )
			DebugEnterAlt(1);
			// SQL.g:
			{
			DebugLocation(282, 20);
			if ((input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z'))
			{
				input.Consume();
			state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}


			}

		}
		finally
		{
			TraceOut("LetterChar", 36);
			LeaveRule("LetterChar", 36);
			Leave_LetterChar();
		}
	}
	// $ANTLR end "LetterChar"

	partial void Enter_DigitChar();
	partial void Leave_DigitChar();

	// $ANTLR start "DigitChar"
	[GrammarRule("DigitChar")]
	private void mDigitChar()
	{
		Enter_DigitChar();
		EnterRule("DigitChar", 37);
		TraceIn("DigitChar", 37);
		try
		{
			// SQL.g:283:19: ( '0' .. '9' )
			DebugEnterAlt(1);
			// SQL.g:283:21: '0' .. '9'
			{
			DebugLocation(283, 21);
			MatchRange('0','9'); if (state.failed) return;

			}

		}
		finally
		{
			TraceOut("DigitChar", 37);
			LeaveRule("DigitChar", 37);
			Leave_DigitChar();
		}
	}
	// $ANTLR end "DigitChar"

	partial void Enter_TextNode();
	partial void Leave_TextNode();

	// $ANTLR start "TextNode"
	[GrammarRule("TextNode")]
	private void mTextNode()
	{
		Enter_TextNode();
		EnterRule("TextNode", 38);
		TraceIn("TextNode", 38);
		try
		{
			// SQL.g:286:18: ()
			DebugEnterAlt(1);
			// SQL.g:286:19: 
			{
			}

		}
		finally
		{
			TraceOut("TextNode", 38);
			LeaveRule("TextNode", 38);
			Leave_TextNode();
		}
	}
	// $ANTLR end "TextNode"

	partial void Enter_SelectClause();
	partial void Leave_SelectClause();

	// $ANTLR start "SelectClause"
	[GrammarRule("SelectClause")]
	private void mSelectClause()
	{
		Enter_SelectClause();
		EnterRule("SelectClause", 39);
		TraceIn("SelectClause", 39);
		try
		{
			// SQL.g:287:22: ()
			DebugEnterAlt(1);
			// SQL.g:287:23: 
			{
			}

		}
		finally
		{
			TraceOut("SelectClause", 39);
			LeaveRule("SelectClause", 39);
			Leave_SelectClause();
		}
	}
	// $ANTLR end "SelectClause"

	partial void Enter_SelectStmt();
	partial void Leave_SelectStmt();

	// $ANTLR start "SelectStmt"
	[GrammarRule("SelectStmt")]
	private void mSelectStmt()
	{
		Enter_SelectStmt();
		EnterRule("SelectStmt", 40);
		TraceIn("SelectStmt", 40);
		try
		{
			// SQL.g:289:20: ()
			DebugEnterAlt(1);
			// SQL.g:289:21: 
			{
			}

		}
		finally
		{
			TraceOut("SelectStmt", 40);
			LeaveRule("SelectStmt", 40);
			Leave_SelectStmt();
		}
	}
	// $ANTLR end "SelectStmt"

	partial void Enter_WhereClause();
	partial void Leave_WhereClause();

	// $ANTLR start "WhereClause"
	[GrammarRule("WhereClause")]
	private void mWhereClause()
	{
		Enter_WhereClause();
		EnterRule("WhereClause", 41);
		TraceIn("WhereClause", 41);
		try
		{
			// SQL.g:290:21: ()
			DebugEnterAlt(1);
			// SQL.g:290:22: 
			{
			}

		}
		finally
		{
			TraceOut("WhereClause", 41);
			LeaveRule("WhereClause", 41);
			Leave_WhereClause();
		}
	}
	// $ANTLR end "WhereClause"

	partial void Enter_Table();
	partial void Leave_Table();

	// $ANTLR start "Table"
	[GrammarRule("Table")]
	private void mTable()
	{
		Enter_Table();
		EnterRule("Table", 42);
		TraceIn("Table", 42);
		try
		{
			// SQL.g:301:15: ()
			DebugEnterAlt(1);
			// SQL.g:301:16: 
			{
			}

		}
		finally
		{
			TraceOut("Table", 42);
			LeaveRule("Table", 42);
			Leave_Table();
		}
	}
	// $ANTLR end "Table"

	partial void Enter_Column();
	partial void Leave_Column();

	// $ANTLR start "Column"
	[GrammarRule("Column")]
	private void mColumn()
	{
		Enter_Column();
		EnterRule("Column", 43);
		TraceIn("Column", 43);
		try
		{
			// SQL.g:303:16: ()
			DebugEnterAlt(1);
			// SQL.g:303:17: 
			{
			}

		}
		finally
		{
			TraceOut("Column", 43);
			LeaveRule("Column", 43);
			Leave_Column();
		}
	}
	// $ANTLR end "Column"

	partial void Enter_Predicate();
	partial void Leave_Predicate();

	// $ANTLR start "Predicate"
	[GrammarRule("Predicate")]
	private void mPredicate()
	{
		Enter_Predicate();
		EnterRule("Predicate", 44);
		TraceIn("Predicate", 44);
		try
		{
			// SQL.g:304:19: ()
			DebugEnterAlt(1);
			// SQL.g:304:20: 
			{
			}

		}
		finally
		{
			TraceOut("Predicate", 44);
			LeaveRule("Predicate", 44);
			Leave_Predicate();
		}
	}
	// $ANTLR end "Predicate"

	partial void Enter_Group();
	partial void Leave_Group();

	// $ANTLR start "Group"
	[GrammarRule("Group")]
	private void mGroup()
	{
		Enter_Group();
		EnterRule("Group", 45);
		TraceIn("Group", 45);
		try
		{
			int _type = Group;
			int _channel = DefaultTokenChannel;
			// SQL.g:308:6: ()
			DebugEnterAlt(1);
			// SQL.g:308:7: 
			{
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("Group", 45);
			LeaveRule("Group", 45);
			Leave_Group();
		}
	}
	// $ANTLR end "Group"

	public override void mTokens()
	{
		// SQL.g:1:8: ( Eq | Neq1 | Neq2 | Le1 | Le2 | Lt | Ge1 | Ge2 | Gt | DIV | PLUS | MINUS | MUL | MOD | BITAND | BITNOT | BITOR | BITXOR | LPAREN | RPAREN | COLON | COMMA | SEMI | DOT | AND | OR | NOT | SELECT | WHERE | FROM | Whitespace | Integer | Txt | NonQuotedIdentifier | Group )
		int alt8=35;
		try { DebugEnterDecision(8, decisionCanBacktrack[8]);
		try
		{
			alt8 = dfa8.Predict(input);
		}
		catch (NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
			throw;
		}
		} finally { DebugExitDecision(8); }
		switch (alt8)
		{
		case 1:
			DebugEnterAlt(1);
			// SQL.g:1:10: Eq
			{
			DebugLocation(1, 10);
			mEq(); if (state.failed) return;

			}
			break;
		case 2:
			DebugEnterAlt(2);
			// SQL.g:1:13: Neq1
			{
			DebugLocation(1, 13);
			mNeq1(); if (state.failed) return;

			}
			break;
		case 3:
			DebugEnterAlt(3);
			// SQL.g:1:18: Neq2
			{
			DebugLocation(1, 18);
			mNeq2(); if (state.failed) return;

			}
			break;
		case 4:
			DebugEnterAlt(4);
			// SQL.g:1:23: Le1
			{
			DebugLocation(1, 23);
			mLe1(); if (state.failed) return;

			}
			break;
		case 5:
			DebugEnterAlt(5);
			// SQL.g:1:27: Le2
			{
			DebugLocation(1, 27);
			mLe2(); if (state.failed) return;

			}
			break;
		case 6:
			DebugEnterAlt(6);
			// SQL.g:1:31: Lt
			{
			DebugLocation(1, 31);
			mLt(); if (state.failed) return;

			}
			break;
		case 7:
			DebugEnterAlt(7);
			// SQL.g:1:34: Ge1
			{
			DebugLocation(1, 34);
			mGe1(); if (state.failed) return;

			}
			break;
		case 8:
			DebugEnterAlt(8);
			// SQL.g:1:38: Ge2
			{
			DebugLocation(1, 38);
			mGe2(); if (state.failed) return;

			}
			break;
		case 9:
			DebugEnterAlt(9);
			// SQL.g:1:42: Gt
			{
			DebugLocation(1, 42);
			mGt(); if (state.failed) return;

			}
			break;
		case 10:
			DebugEnterAlt(10);
			// SQL.g:1:45: DIV
			{
			DebugLocation(1, 45);
			mDIV(); if (state.failed) return;

			}
			break;
		case 11:
			DebugEnterAlt(11);
			// SQL.g:1:49: PLUS
			{
			DebugLocation(1, 49);
			mPLUS(); if (state.failed) return;

			}
			break;
		case 12:
			DebugEnterAlt(12);
			// SQL.g:1:54: MINUS
			{
			DebugLocation(1, 54);
			mMINUS(); if (state.failed) return;

			}
			break;
		case 13:
			DebugEnterAlt(13);
			// SQL.g:1:60: MUL
			{
			DebugLocation(1, 60);
			mMUL(); if (state.failed) return;

			}
			break;
		case 14:
			DebugEnterAlt(14);
			// SQL.g:1:64: MOD
			{
			DebugLocation(1, 64);
			mMOD(); if (state.failed) return;

			}
			break;
		case 15:
			DebugEnterAlt(15);
			// SQL.g:1:68: BITAND
			{
			DebugLocation(1, 68);
			mBITAND(); if (state.failed) return;

			}
			break;
		case 16:
			DebugEnterAlt(16);
			// SQL.g:1:75: BITNOT
			{
			DebugLocation(1, 75);
			mBITNOT(); if (state.failed) return;

			}
			break;
		case 17:
			DebugEnterAlt(17);
			// SQL.g:1:82: BITOR
			{
			DebugLocation(1, 82);
			mBITOR(); if (state.failed) return;

			}
			break;
		case 18:
			DebugEnterAlt(18);
			// SQL.g:1:88: BITXOR
			{
			DebugLocation(1, 88);
			mBITXOR(); if (state.failed) return;

			}
			break;
		case 19:
			DebugEnterAlt(19);
			// SQL.g:1:95: LPAREN
			{
			DebugLocation(1, 95);
			mLPAREN(); if (state.failed) return;

			}
			break;
		case 20:
			DebugEnterAlt(20);
			// SQL.g:1:102: RPAREN
			{
			DebugLocation(1, 102);
			mRPAREN(); if (state.failed) return;

			}
			break;
		case 21:
			DebugEnterAlt(21);
			// SQL.g:1:109: COLON
			{
			DebugLocation(1, 109);
			mCOLON(); if (state.failed) return;

			}
			break;
		case 22:
			DebugEnterAlt(22);
			// SQL.g:1:115: COMMA
			{
			DebugLocation(1, 115);
			mCOMMA(); if (state.failed) return;

			}
			break;
		case 23:
			DebugEnterAlt(23);
			// SQL.g:1:121: SEMI
			{
			DebugLocation(1, 121);
			mSEMI(); if (state.failed) return;

			}
			break;
		case 24:
			DebugEnterAlt(24);
			// SQL.g:1:126: DOT
			{
			DebugLocation(1, 126);
			mDOT(); if (state.failed) return;

			}
			break;
		case 25:
			DebugEnterAlt(25);
			// SQL.g:1:130: AND
			{
			DebugLocation(1, 130);
			mAND(); if (state.failed) return;

			}
			break;
		case 26:
			DebugEnterAlt(26);
			// SQL.g:1:134: OR
			{
			DebugLocation(1, 134);
			mOR(); if (state.failed) return;

			}
			break;
		case 27:
			DebugEnterAlt(27);
			// SQL.g:1:137: NOT
			{
			DebugLocation(1, 137);
			mNOT(); if (state.failed) return;

			}
			break;
		case 28:
			DebugEnterAlt(28);
			// SQL.g:1:141: SELECT
			{
			DebugLocation(1, 141);
			mSELECT(); if (state.failed) return;

			}
			break;
		case 29:
			DebugEnterAlt(29);
			// SQL.g:1:148: WHERE
			{
			DebugLocation(1, 148);
			mWHERE(); if (state.failed) return;

			}
			break;
		case 30:
			DebugEnterAlt(30);
			// SQL.g:1:154: FROM
			{
			DebugLocation(1, 154);
			mFROM(); if (state.failed) return;

			}
			break;
		case 31:
			DebugEnterAlt(31);
			// SQL.g:1:159: Whitespace
			{
			DebugLocation(1, 159);
			mWhitespace(); if (state.failed) return;

			}
			break;
		case 32:
			DebugEnterAlt(32);
			// SQL.g:1:170: Integer
			{
			DebugLocation(1, 170);
			mInteger(); if (state.failed) return;

			}
			break;
		case 33:
			DebugEnterAlt(33);
			// SQL.g:1:178: Txt
			{
			DebugLocation(1, 178);
			mTxt(); if (state.failed) return;

			}
			break;
		case 34:
			DebugEnterAlt(34);
			// SQL.g:1:182: NonQuotedIdentifier
			{
			DebugLocation(1, 182);
			mNonQuotedIdentifier(); if (state.failed) return;

			}
			break;
		case 35:
			DebugEnterAlt(35);
			// SQL.g:1:202: Group
			{
			DebugLocation(1, 202);
			mGroup(); if (state.failed) return;

			}
			break;

		}

	}


	#region DFA
	DFA8 dfa8;

	protected override void InitDFAs()
	{
		base.InitDFAs();
		dfa8 = new DFA8(this);
	}

	private class DFA8 : DFA
	{
		private const string DFA8_eotS =
			"\x1\x1E\x1\xFFFF\x1\x21\x1\xFFFF\x1\x26\xF\xFFFF\x6\x1D\xD\xFFFF\x1"+
			"\x1D\x1\x2E\x4\x1D\x1\x33\x1\xFFFF\x1\x34\x3\x1D\x2\xFFFF\x2\x1D\x1\x3A"+
			"\x1\x1D\x1\x3C\x1\xFFFF\x1\x3D\x2\xFFFF";
		private const string DFA8_eofS =
			"\x3E\xFFFF";
		private const string DFA8_minS =
			"\x1\x9\x1\xFFFF\x1\x3D\x1\x3C\x1\x3D\xF\xFFFF\x1\x4E\x1\x52\x1\x4F\x1"+
			"\x45\x1\x48\x1\x52\xD\xFFFF\x1\x44\x1\x2E\x1\x54\x1\x4C\x1\x45\x1\x4F"+
			"\x1\x2E\x1\xFFFF\x1\x2E\x1\x45\x1\x52\x1\x4D\x2\xFFFF\x1\x43\x1\x45\x1"+
			"\x2E\x1\x54\x1\x2E\x1\xFFFF\x1\x2E\x2\xFFFF";
		private const string DFA8_maxS =
			"\x1\x7E\x1\xFFFF\x2\x3E\x1\x3D\xF\xFFFF\x1\x6E\x1\x72\x1\x6F\x1\x65"+
			"\x1\x68\x1\x72\xD\xFFFF\x1\x64\x1\x7A\x1\x74\x1\x6C\x1\x65\x1\x6F\x1"+
			"\x7A\x1\xFFFF\x1\x7A\x1\x65\x1\x72\x1\x6D\x2\xFFFF\x1\x63\x1\x65\x1\x7A"+
			"\x1\x74\x1\x7A\x1\xFFFF\x1\x7A\x2\xFFFF";
		private const string DFA8_acceptS =
			"\x1\xFFFF\x1\x1\x3\xFFFF\x1\xA\x1\xB\x1\xC\x1\xD\x1\xE\x1\xF\x1\x10"+
			"\x1\x11\x1\x12\x1\x13\x1\x14\x1\x15\x1\x16\x1\x17\x1\x18\x6\xFFFF\x1"+
			"\x1F\x1\x20\x1\x21\x1\x22\x1\x23\x1\x2\x1\x4\x1\x6\x1\x3\x1\x5\x1\x8"+
			"\x1\x7\x1\x9\x7\xFFFF\x1\x1A\x4\xFFFF\x1\x19\x1\x1B\x5\xFFFF\x1\x1E\x1"+
			"\xFFFF\x1\x1D\x1\x1C";
		private const string DFA8_specialS =
			"\x3E\xFFFF}>";
		private static readonly string[] DFA8_transitionS =
			{
				"\x2\x1A\x2\xFFFF\x1\x1A\x12\xFFFF\x1\x1A\x1\x3\x1\x1C\x2\xFFFF\x1\x9"+
				"\x1\xA\x1\x1C\x1\xE\x1\xF\x1\x8\x1\x6\x1\x11\x1\x7\x1\x13\x1\x5\xA\x1B"+
				"\x1\x10\x1\x12\x1\x2\x1\x1\x1\x4\x2\xFFFF\x1\x14\x4\x1D\x1\x19\x7\x1D"+
				"\x1\x16\x1\x15\x3\x1D\x1\x17\x3\x1D\x1\x18\x3\x1D\x3\xFFFF\x1\xD\x2"+
				"\xFFFF\x1\x14\x4\x1D\x1\x19\x7\x1D\x1\x16\x1\x15\x3\x1D\x1\x17\x3\x1D"+
				"\x1\x18\x3\x1D\x1\xFFFF\x1\xC\x1\xFFFF\x1\xB",
				"",
				"\x1\x20\x1\x1F",
				"\x1\x24\x1\x22\x1\x23",
				"\x1\x25",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"\x1\x27\x1F\xFFFF\x1\x27",
				"\x1\x28\x1F\xFFFF\x1\x28",
				"\x1\x29\x1F\xFFFF\x1\x29",
				"\x1\x2A\x1F\xFFFF\x1\x2A",
				"\x1\x2B\x1F\xFFFF\x1\x2B",
				"\x1\x2C\x1F\xFFFF\x1\x2C",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"\x1\x2D\x1F\xFFFF\x1\x2D",
				"\x1\x1D\x1\xFFFF\xA\x1D\x7\xFFFF\x1A\x1D\x4\xFFFF\x1\x1D\x1\xFFFF"+
				"\x1A\x1D",
				"\x1\x2F\x1F\xFFFF\x1\x2F",
				"\x1\x30\x1F\xFFFF\x1\x30",
				"\x1\x31\x1F\xFFFF\x1\x31",
				"\x1\x32\x1F\xFFFF\x1\x32",
				"\x1\x1D\x1\xFFFF\xA\x1D\x7\xFFFF\x1A\x1D\x4\xFFFF\x1\x1D\x1\xFFFF"+
				"\x1A\x1D",
				"",
				"\x1\x1D\x1\xFFFF\xA\x1D\x7\xFFFF\x1A\x1D\x4\xFFFF\x1\x1D\x1\xFFFF"+
				"\x1A\x1D",
				"\x1\x35\x1F\xFFFF\x1\x35",
				"\x1\x36\x1F\xFFFF\x1\x36",
				"\x1\x37\x1F\xFFFF\x1\x37",
				"",
				"",
				"\x1\x38\x1F\xFFFF\x1\x38",
				"\x1\x39\x1F\xFFFF\x1\x39",
				"\x1\x1D\x1\xFFFF\xA\x1D\x7\xFFFF\x1A\x1D\x4\xFFFF\x1\x1D\x1\xFFFF"+
				"\x1A\x1D",
				"\x1\x3B\x1F\xFFFF\x1\x3B",
				"\x1\x1D\x1\xFFFF\xA\x1D\x7\xFFFF\x1A\x1D\x4\xFFFF\x1\x1D\x1\xFFFF"+
				"\x1A\x1D",
				"",
				"\x1\x1D\x1\xFFFF\xA\x1D\x7\xFFFF\x1A\x1D\x4\xFFFF\x1\x1D\x1\xFFFF"+
				"\x1A\x1D",
				"",
				""
			};

		private static readonly short[] DFA8_eot = DFA.UnpackEncodedString(DFA8_eotS);
		private static readonly short[] DFA8_eof = DFA.UnpackEncodedString(DFA8_eofS);
		private static readonly char[] DFA8_min = DFA.UnpackEncodedStringToUnsignedChars(DFA8_minS);
		private static readonly char[] DFA8_max = DFA.UnpackEncodedStringToUnsignedChars(DFA8_maxS);
		private static readonly short[] DFA8_accept = DFA.UnpackEncodedString(DFA8_acceptS);
		private static readonly short[] DFA8_special = DFA.UnpackEncodedString(DFA8_specialS);
		private static readonly short[][] DFA8_transition;

		static DFA8()
		{
			int numStates = DFA8_transitionS.Length;
			DFA8_transition = new short[numStates][];
			for ( int i=0; i < numStates; i++ )
			{
				DFA8_transition[i] = DFA.UnpackEncodedString(DFA8_transitionS[i]);
			}
		}

		public DFA8( BaseRecognizer recognizer )
		{
			this.recognizer = recognizer;
			this.decisionNumber = 8;
			this.eot = DFA8_eot;
			this.eof = DFA8_eof;
			this.min = DFA8_min;
			this.max = DFA8_max;
			this.accept = DFA8_accept;
			this.special = DFA8_special;
			this.transition = DFA8_transition;
		}

		public override string Description { get { return "1:1: Tokens : ( Eq | Neq1 | Neq2 | Le1 | Le2 | Lt | Ge1 | Ge2 | Gt | DIV | PLUS | MINUS | MUL | MOD | BITAND | BITNOT | BITOR | BITXOR | LPAREN | RPAREN | COLON | COMMA | SEMI | DOT | AND | OR | NOT | SELECT | WHERE | FROM | Whitespace | Integer | Txt | NonQuotedIdentifier | Group );"; } }

		public override void Error(NoViableAltException nvae)
		{
			DebugRecognitionException(nvae);
		}
	}

 
	#endregion

}

} // namespace  Magic.Framework.OQL
